// ============================================================================
// 定时任务服务 - 管理定时任务的前端服务
// ============================================================================

import { ipcService } from './ipc-service'
import { ScrapeTask, ScheduledTaskParams } from '../../shared/types'
import { IPC_EVENTS } from '../../shared/constants'
import { logger } from '../utils/logger'

/**
 * 创建定时任务的选项
 */
export interface CreateScheduledTaskOptions {
  interval?: number // 执行间隔（毫秒）
  maxPages?: number // 每个关键字最大爬取页数
  enabled?: boolean // 是否启用
  cronExpression?: string // 可选的cron表达式
  count?: number // 爬取数量
  dateRange?: [Date, Date] // 日期范围
}

/**
 * 更新定时任务的选项
 */
export interface UpdateScheduledTaskOptions {
  keywords?: string[]
  interval?: number
  maxPages?: number
  enabled?: boolean
  cronExpression?: string
}

/**
 * 调度器状态
 */
export interface SchedulerStatus {
  isRunning: boolean
  activeJobs: number
  totalJobs: number
  lastExecution?: Date
  nextExecution?: Date
  errors: string[]
}

/**
 * 定时任务服务类
 */
export class SchedulerService {
  private static instance: SchedulerService

  private constructor() {}

  /**
   * 获取单例实例
   */
  static getInstance(): SchedulerService {
    if (!SchedulerService.instance) {
      SchedulerService.instance = new SchedulerService()
    }
    return SchedulerService.instance
  }

  /**
   * 创建定时任务
   */
  async createScheduledTask(
    keywords: string[],
    accountId: string,
    options: CreateScheduledTaskOptions = {}
  ): Promise<string> {
    try {
      logger.info('创建定时任务', { keywords, accountId, options })
      
      const taskId = await ipcService.invoke<string>(
        IPC_EVENTS.SCHEDULER_CREATE_TASK,
        keywords,
        accountId,
        options
      )
      
      logger.info('定时任务创建成功', { taskId })
      return taskId
    } catch (error) {
      logger.error('创建定时任务失败', error)
      throw error
    }
  }

  /**
   * 更新定时任务
   */
  async updateScheduledTask(
    taskId: string,
    updates: UpdateScheduledTaskOptions
  ): Promise<void> {
    try {
      logger.info('更新定时任务', { taskId, updates })
      
      await ipcService.invoke(
        IPC_EVENTS.SCHEDULER_UPDATE_TASK,
        taskId,
        updates
      )
      
      logger.info('定时任务更新成功', { taskId })
    } catch (error) {
      logger.error('更新定时任务失败', error)
      throw error
    }
  }

  /**
   * 删除定时任务
   */
  async deleteScheduledTask(taskId: string): Promise<void> {
    try {
      logger.info('删除定时任务', { taskId })
      
      await ipcService.invoke(
        IPC_EVENTS.SCHEDULER_DELETE_TASK,
        taskId
      )
      
      logger.info('定时任务删除成功', { taskId })
    } catch (error) {
      logger.error('删除定时任务失败', error)
      throw error
    }
  }

  /**
   * 获取所有定时任务
   */
  async getAllScheduledTasks(): Promise<ScrapeTask[]> {
    try {
      logger.debug('获取所有定时任务')
      
      const tasks = await ipcService.invoke<ScrapeTask[]>(
        IPC_EVENTS.SCHEDULER_GET_ALL_TASKS
      )
      
      logger.debug('获取定时任务成功', { count: tasks.length })
      return tasks
    } catch (error) {
      logger.error('获取定时任务失败', error)
      throw error
    }
  }

  /**
   * 立即执行定时任务
   */
  async executeTaskNow(taskId: string): Promise<void> {
    try {
      logger.info('立即执行定时任务', { taskId })
      
      await ipcService.invoke(
        IPC_EVENTS.SCHEDULER_EXECUTE_NOW,
        taskId
      )
      
      logger.info('定时任务执行成功', { taskId })
    } catch (error) {
      logger.error('立即执行定时任务失败', error)
      throw error
    }
  }

  /**
   * 获取调度器状态
   */
  async getSchedulerStatus(): Promise<SchedulerStatus> {
    try {
      const status = await ipcService.invoke<SchedulerStatus>(
        IPC_EVENTS.SCHEDULER_GET_STATUS
      )
      return status
    } catch (error) {
      logger.error('获取调度器状态失败', error)
      throw error
    }
  }

  /**
   * 启动调度器
   */
  async startScheduler(): Promise<void> {
    try {
      logger.info('启动调度器')
      
      await ipcService.invoke(IPC_EVENTS.SCHEDULER_START)
      
      logger.info('调度器启动成功')
    } catch (error) {
      logger.error('启动调度器失败', error)
      throw error
    }
  }

  /**
   * 停止调度器
   */
  async stopScheduler(): Promise<void> {
    try {
      logger.info('停止调度器')
      
      await ipcService.invoke(IPC_EVENTS.SCHEDULER_STOP)
      
      logger.info('调度器停止成功')
    } catch (error) {
      logger.error('停止调度器失败', error)
      throw error
    }
  }

  /**
   * 格式化时间间隔显示
   */
  formatInterval(intervalMs: number): string {
    const minutes = Math.floor(intervalMs / (1000 * 60))
    const hours = Math.floor(minutes / 60)
    const days = Math.floor(hours / 24)

    if (days > 0) {
      return `${days}天${hours % 24}小时`
    } else if (hours > 0) {
      return `${hours}小时${minutes % 60}分钟`
    } else {
      return `${minutes}分钟`
    }
  }

  /**
   * 解析时间间隔输入
   */
  parseInterval(input: string): number {
    const value = parseInt(input)
    if (isNaN(value) || value <= 0) {
      throw new Error('请输入有效的时间间隔')
    }
    return value * 60 * 1000 // 转换为毫秒
  }

  /**
   * 验证关键字列表
   */
  validateKeywords(keywords: string[]): string[] {
    const validKeywords = keywords
      .map(k => k.trim())
      .filter(k => k.length > 0)
    
    if (validKeywords.length === 0) {
      throw new Error('请至少输入一个有效的关键字')
    }
    
    return validKeywords
  }

  /**
   * 获取任务状态显示文本
   */
  getTaskStatusText(status: string): string {
    const statusMap: Record<string, string> = {
      'pending': '等待中',
      'scheduled': '已调度',
      'running': '运行中',
      'completed': '已完成',
      'failed': '失败',
      'cancelled': '已取消'
    }
    return statusMap[status] || status
  }

  /**
   * 获取任务状态颜色
   */
  getTaskStatusColor(status: string): string {
    const colorMap: Record<string, string> = {
      'pending': 'text-yellow-600',
      'scheduled': 'text-purple-600',
      'running': 'text-blue-600',
      'completed': 'text-green-600',
      'failed': 'text-red-600',
      'cancelled': 'text-gray-600'
    }
    return colorMap[status] || 'text-gray-600'
  }
}

/**
 * 全局定时任务服务实例
 */
export const schedulerService = SchedulerService.getInstance()
